import express, { Router, Request, Response } from 'express';
import { PrismaClient, UserTier, Prisma } from '@prisma/client';
import { ResponseHelper } from '../../utils/response';

const router: Router = express.Router();
const prisma = new PrismaClient();

/**
 * GET /api/admin/tiers
 * 获取所有等级配置
 */
router.get('/', async (req: Request, res: Response) => {
  try {
    const tiers = await prisma.tierConfig.findMany({
      orderBy: {
        minInvestment: 'asc',
      },
    });

    // 转换 Decimal 类型为数字
    const formattedTiers = tiers.map(tier => ({
      id: tier.id,
      tier: tier.tier,
      name: tier.name,
      dailyRate: Number(tier.dailyRate),
      monthlyRate: Number(tier.monthlyRate),
      annualRate: Number(tier.annualRate),
      minInvestment: Number(tier.minInvestment),
      isActive: tier.isActive,
      createdAt: tier.createdAt,
      updatedAt: tier.updatedAt,
    }));

    return ResponseHelper.success(res, formattedTiers, '등급 구성을 성공적으로 불러왔습니다.');
  } catch (error) {
    console.error('获取等级配置失败:', error);
    return ResponseHelper.error(res, '등급 구성을 불러오지 못했습니다.');
  }
});

/**
 * PUT /api/admin/tiers/:tier
 * 更新等级配置
 * 当修改日收益率时，自动计算月收益率和年收益率
 */
router.put('/:tier', async (req: Request, res: Response) => {
  try {
    const { tier } = req.params;
    const { dailyRate, minInvestment } = req.body;

    // 验证等级是否有效
    if (!Object.values(UserTier).includes(tier as UserTier)) {
      return ResponseHelper.error(res, '유효하지 않은 등급입니다.', 400);
    }

    // 验证日收益率范围（0.001 - 0.05，即0.1% - 5%）
    if (dailyRate < 0.001 || dailyRate > 0.05) {
      return ResponseHelper.error(res, '일일 수익률은 0.1% 이상 5% 이하로 설정해야 합니다.', 400);
    }

    // 自动计算月收益率和年收益率
    const monthlyRate = dailyRate * 30;
    const annualRate = dailyRate * 360;

    const updatedTier = await prisma.tierConfig.update({
      where: { tier: tier as UserTier },
      data: {
        dailyRate,
        monthlyRate,
        annualRate,
        ...(minInvestment !== undefined && { minInvestment }),
      },
    });

    return ResponseHelper.success(res, updatedTier, '등급 구성이 성공적으로 업데이트되었습니다.');
  } catch (error) {
    console.error('更新等级配置失败:', error);
    return ResponseHelper.error(res, '등급 구성을 업데이트하지 못했습니다.');
  }
});

/**
 * POST /api/admin/users/:id/tier
 * 变更用户等级
 * 等级变更后：
 * 1. 立即生效
 * 2. 结算当前收益
 * 3. 更新用户的日收益率为新等级的收益率
 */
router.post('/users/:id/tier', async (req: Request, res: Response) => {
  try {
    const userId = parseInt(req.params.id);
    const { tier } = req.body;

    if (!userId || isNaN(userId)) {
      return ResponseHelper.error(res, '유효하지 않은 사용자 ID입니다.', 400);
    }

    // 验证等级是否有效
    if (!Object.values(UserTier).includes(tier as UserTier)) {
      return ResponseHelper.error(res, '유효하지 않은 등급입니다.', 400);
    }

    // 获取用户信息
    const user = await prisma.user.findUnique({
      where: { id: userId },
      include: { stakingInfo: true },
    });

    if (!user) {
      return ResponseHelper.error(res, '사용자를 찾을 수 없습니다.', 404);
    }

    // 获取新等级的配置
    const newTierConfig = await prisma.tierConfig.findUnique({
      where: { tier: tier as UserTier },
    });

    if (!newTierConfig) {
      return ResponseHelper.error(res, '등급 구성이 존재하지 않습니다.', 404);
    }

    // 使用事务确保原子性
    await prisma.$transaction(async (tx: Prisma.TransactionClient) => {
      // 1. 更新用户等级
      await tx.user.update({
        where: { id: userId },
        data: { tier: tier as UserTier },
      });

      // 2. 如果用户有质押信息，需要结算当前收益并更新收益率
      if (user.stakingInfo) {
        const now = new Date();
        const stakingInfo = user.stakingInfo;

        // 结算当前收益（如果有未结算的收益）
        const currentReward = Number(stakingInfo.currentDailyReward);
        const distributedReward = Number(stakingInfo.dailyRewardDistributed);

        if (currentReward > distributedReward) {
          const pendingReward = currentReward - distributedReward;

          await tx.userStaking.update({
            where: { userId },
            data: {
              totalRewardsNear: {
                increment: pendingReward,
              },
              dailyRewardDistributed: currentReward,
            },
          });
        }

        // 3. 更新收益率为新等级的收益率
        // 重置当日收益相关字段，下次分发时会按新收益率计算
        await tx.userStaking.update({
          where: { userId },
          data: {
            dailyRewardRate: newTierConfig.dailyRate,
            currentDailyReward: 0,
            dailyRewardDistributed: 0,
            dailyDistributionCount: 0,
            lastCalculationDate: now,
          },
        });

        console.log(`用户 ${userId} 等级变更: ${user.tier} -> ${tier}, 新收益率: ${newTierConfig.dailyRate}`);
      }
    });

    return ResponseHelper.success(
      res,
      {
        userId,
        oldTier: user.tier,
        newTier: tier,
        newDailyRate: newTierConfig.dailyRate,
      },
      '사용자 등급이 성공적으로 변경되었습니다.'
    );
  } catch (error) {
    console.error('变更用户等级失败:', error);
    return ResponseHelper.error(res, '사용자 등급을 변경하지 못했습니다.');
  }
});

/**
 * GET /api/admin/users/:id/tier-info
 * 获取用户的等级详细信息
 */
router.get('/users/:id/tier-info', async (req: Request, res: Response) => {
  try {
    const userId = parseInt(req.params.id);

    if (!userId || isNaN(userId)) {
      return ResponseHelper.error(res, '유효하지 않은 사용자 ID입니다.', 400);
    }

    const user = await prisma.user.findUnique({
      where: { id: userId },
      include: {
        stakingInfo: true,
      },
    });

    if (!user) {
      return ResponseHelper.error(res, '사용자를 찾을 수 없습니다.', 404);
    }

    const tierConfig = await prisma.tierConfig.findUnique({
      where: { tier: user.tier },
    });

    return ResponseHelper.success(
      res,
      {
        userId: user.id,
        name: user.name,
        currentTier: user.tier,
        tierConfig,
        stakingInfo: user.stakingInfo,
      },
      '사용자 등급 정보를 성공적으로 조회했습니다.'
    );
  } catch (error) {
    console.error('获取用户等级信息失败:', error);
    return ResponseHelper.error(res, '사용자 등급 정보를 조회하지 못했습니다.');
  }
});

export default router;
